34 research outputs found
Relaxing state-access constraints in stateful programmable data planes
Supporting the programming of stateful packet forwarding functions in
hardware has recently attracted the interest of the research community. When
designing such switching chips, the challenge is to guarantee the ability to
program functions that can read and modify data plane's state, while keeping
line rate performance and state consistency. Current state-of-the-art designs
are based on a very conservative all-or-nothing model: programmability is
limited only to those functions that are guaranteed to sustain line rate, with
any traffic workload. In effect, this limits the maximum time to execute state
update operations. In this paper, we explore possible options to relax these
constraints by using simulations on real traffic traces. We then propose a
model in which functions can be executed in a larger but bounded time, while
preventing data hazards with memory locking. We present results showing that
such flexibility can be supported with little or no throughput degradation.Comment: 6 page
Traffic Management Applications for Stateful SDN Data Plane
The successful OpenFlow approach to Software Defined Networking (SDN) allows
network programmability through a central controller able to orchestrate a set
of dumb switches. However, the simple match/action abstraction of OpenFlow
switches constrains the evolution of the forwarding rules to be fully managed
by the controller. This can be particularly limiting for a number of
applications that are affected by the delay of the slow control path, like
traffic management applications. Some recent proposals are pushing toward an
evolution of the OpenFlow abstraction to enable the evolution of forwarding
policies directly in the data plane based on state machines and local events.
In this paper, we present two traffic management applications that exploit a
stateful data plane and their prototype implementation based on OpenState, an
OpenFlow evolution that we recently proposed.Comment: 6 pages, 9 figure
SPIDER: Fault Resilient SDN Pipeline with Recovery Delay Guarantees
When dealing with node or link failures in Software Defined Networking (SDN),
the network capability to establish an alternative path depends on controller
reachability and on the round trip times (RTTs) between controller and involved
switches. Moreover, current SDN data plane abstractions for failure detection
(e.g. OpenFlow "Fast-failover") do not allow programmers to tweak switches'
detection mechanism, thus leaving SDN operators still relying on proprietary
management interfaces (when available) to achieve guaranteed detection and
recovery delays. We propose SPIDER, an OpenFlow-like pipeline design that
provides i) a detection mechanism based on switches' periodic link probing and
ii) fast reroute of traffic flows even in case of distant failures, regardless
of controller availability. SPIDER can be implemented using stateful data plane
abstractions such as OpenState or Open vSwitch, and it offers guaranteed short
(i.e. ms) failure detection and recovery delays, with a configurable trade off
between overhead and failover responsiveness. We present here the SPIDER
pipeline design, behavioral model, and analysis on flow tables' memory impact.
We also implemented and experimentally validated SPIDER using OpenState (an
OpenFlow 1.3 extension for stateful packet processing), showing numerical
results on its performance in terms of recovery latency and packet losses.Comment: 8 page
Stateful Data Plane Abstractions for Software-Defined Networks and Their Applications
RESUMÉ
Le Software-Defined Networking (SDN) permet la programmation du réseau. Malheureusement, la technologie SDN actuelle limite la programmabilité uniquement au plan de contrôle. Les opérateurs ne peuvent pas programmer des algorithmes du plan de données tels que l’équilibrage de charge, le contrôle de congestion, la détection de pannes, etc. Ces fonctions sont implémentées à l’aide d’hardware dédié, car elles doivent fonctionner au taux de ligne,
c’est-à -dire 10-100 Gbit/s sur 10-100 ports. Dans ce travail, nous présentons deux abstractions de plan de données pour le traitement de paquets à états (stateful), OpenState et OPP. OpenState est une extension d’OpenFlow
qui permet la définition des règles de flux en tant que machines à états finis. OPP est une abstraction plus flexible qui généralise OpenState en ajoutant des capacités de calcul, permettant la programmation d’algorithmes de plan de données plus avancés. OpenState et OPP sont à la fois disponibles pour les implémentations d’haute performance en utilisant des composants de commutateurs hardware courants. Cependant, les deux abstractions sont
basées sur un choix de design problématique : l’utilisation d’une boucle de rétroaction dans le pipeline de traitement des paquets. Cette boucle, si elle n’est pas correctement contrôlée, peut nuire à la cohérence des opérations d’état. Les approches de verrouillage de la mémoire peuvent être utilisées pour éviter les incohérences, au détriment du débit. Nous présentons des résultats de simulations sur des traces de trafic réelles, montrant que les boucles de rétroaction de plusieurs cycles d’horloge peuvent être supportées avec peu ou pas de dégradation des
performances, même avec les charges de travail des plus défavorables. Pour mieux prouver les avantages d’un plan de données programmables, nous présentons deux nouvelles applications : Spider et FDPA. Spider permet de détecter et de réagir aux pannes de réseau aux échelles temporelles du plan de données (i.e., micro/nanosecondes), également
dans le cas de pannes à distance. En utilisant OpenState, Spider fournit des fonctionnalités équivalentes aux protocoles de plans de contrôle anciens tels que BFD et MPLS Fast Reroute, mais sans nécessiter un plan de contrôle.---------- ABSTRACT Software-Defined Networking (SDN) enables programmability in the network. Unfortunately,
current SDN limits programmability only to the control plane. Operators cannot program data plane algorithms such as load balancing, congestion control, failure detection, etc. These capabilities are usually baked in the switch via dedicated hardware, as they need to run at line rate, i.e. 10-100 Gbit/s on 10-100 ports. In this work, we present two data plane abstractions for stateful packet processing, namely OpenState and OPP. These abstractions allow operators to program data plane tasks that involve stateful processing. OpenState is an extension to OpenFlow that permits the definition of forwarding rules as finite state machines. OPP is a more flexible abstraction that
generalizes OpenState by adding computational capabilities, opening for the programming of more advanced data plane algorithms. Both OpenState and OPP are amenable for highperformance hardware implementations by using commodity hardware switch components. However, both abstractions are based on a problematic design choice: to use a feedback-loop
in the processing pipeline. This loop, if not adequately controlled, can represent a harm for the consistency of the state operations. Memory locking approaches can be used to prevent inconsistencies, at the expense of throughput. We present simulation results on real traffic traces showing that feedback-loops of several clock cycles can be supported with little or no performance degradation, even with near-worst case traffic workloads. To further prove the benefits of a stateful programmable data plane, we present two novel applications: Spider and FDPA. Spider permits to detect and react to network failures at
data plane timescales, i.e. micro/nanoseconds, also in the case of distant failures. By using OpenState, Spider provides functionalities equivalent to legacy control plane protocols such as BFD and MPLS Fast Reroute, but without the need of a control plane. That is, both detection and rerouting happen entirely in the data plane. FDPA allows a switch to enforce approximate fair bandwidth sharing among many TCP-like senders. Most of the mechanisms to solve this problem are based on complex scheduling algorithms, whose feasibility becomes very expensive with today’s line rate requirements. FDPA, which is based on OPP, trades scheduling complexity with per-user state. FDPA
works by dynamically assigning users to few (3-4) priority queues, where the priority is chosen based on the sending rate history of a user
Detour Planning for Fast and Reliable Failure Recovery in SDN with OpenState
A reliable and scalable mechanism to provide protection against a link or
node failure has additional requirements in the context of SDN and OpenFlow.
Not only it has to minimize the load on the controller, but it must be able to
react even when the controller is unreachable. In this paper we present a
protection scheme based on precomputed backup paths and inspired by MPLS
crankback routing, that guarantees instantaneous recovery times and aims at
zero packet-loss after failure detection, regardless of controller
reachability, even when OpenFlow's "fast-failover" feature cannot be used. The
proposed mechanism is based on OpenState, an OpenFlow extension that allows a
programmer to specify how forwarding rules should autonomously adapt in a
stateful fashion, reducing the need to rely on remote controllers. We present
the scheme as well as two different formulations for the computation of backup
paths.Comment: 8 pages, pre-print, Design of Reliable Communication Networks (DRCN),
2015 11th International Conference on th
Towards approximate fair bandwidth sharing via dynamic priority queuing
We tackle the problem of a network switch enforcing fair bandwidth sharing of the same link among many TCP-like senders. Most of the mechanisms to solve this problem are based on complex scheduling algorithms, whose feasibility becomes very expensive with today's line rate requirements, i.e. 10-100 Gbit/s per port. We propose a new scheme called FDPA in which we do not modify the scheduler, but instead we use an array of rate estimators to dynamically assign traffic flows to an existing strict priority scheduler serving only few queues. FDPA is inspired by recent advances in programmable stateful data planes. We propose a design that uses primitives common in data plane abstractions such as P4 and OpenFlow. We conducted experiments on a physical 10 Gbit/s testbed, we present preliminary results showing that FDPA produces fairness comparable to approaches based on scheduling
The Road to BOFUSS: The Basic OpenFlow User-space Software Switch
Software switches are pivotal in the Software-Defined Networking (SDN)
paradigm, particularly in the early phases of development, deployment and
testing. Currently, the most popular one is Open vSwitch (OVS), leveraged in
many production-based environments. However, due to its kernel-based nature,
OVS is typically complex to modify when additional features or adaptation is
required. To this regard, a simpler user-space is key to perform these
modifications.
In this article, we present a rich overview of BOFUSS, the basic OpenFlow
user-space software switch. BOFUSS has been widely used in the research
community for diverse reasons, but it lacked a proper reference document. For
this purpose, we describe the switch, its history, architecture, uses cases and
evaluation, together with a survey of works that leverage this switch. The main
goal is to provide a comprehensive overview of the switch and its
characteristics. Although the original BOFUSS is not expected to surpass the
high performance of OVS, it is a useful complementary artifact that provides
some OpenFlow features missing in OVS and it can be easily modified for
extended functionality. Moreover, enhancements provided by the BEBA project
brought the performance from BOFUSS close to OVS. In any case, this paper sheds
light to researchers looking for the trade-offs between performance and
customization of BOFUSS.Comment: 24 pages, 7 figures; submitted to Telecommunications Systems journa
Possible application of FPGA to the MAORY Real Time Computer
MAORY is the post-focal Adaptive Optics module for the European Extremely Large Telescope first light. The baseline of MAORY is to rely upon the use of multiple Laser Guide Stars (6), multiple Natural Guide Stars (3) for wavefront sensing and multiple Deformable Mirrors (DM) for correction (M4/M5, that are part of the telescope, and 2 post focal DMs). The Real-Time Computer is a key sub-system of MAORY. It must collect the measurements from various sensing devices and drive several thousands actuators within high demanding latency requirements dictated by the system performance needs. The FPGA technology has been widely diffused in Real Time Systems due to its low latency and high determinism. Performance evaluation of this technology for the wavefront sensors images calibration and processing is in progress